home *** CD-ROM | disk | FTP | other *** search
/ Windows Expert / Windows Expert.iso / windownt / vcntpr.zip / VCNTQ&A.TXT < prev    next >
Text File  |  1993-07-29  |  37KB  |  579 lines
  1.  
  2.          
  3.  
  4.  
  5.  
  6. Microsoft« Visual C++*, 32-Bit Edition:
  7. Most Commonly Asked Questions
  8. July 2, 1993
  9.  
  10.  
  11. For more information contact:
  12.  
  13. Microsoft Corporation
  14. Eric Lang, (206) 882-8080
  15.  
  16. Waggener Edstrom
  17. Martin Middlewood, (503) 245-0905
  18.  
  19.  
  20. General/Policy Section
  21. When will your final NT product be ready?
  22. Visual C++ 32-Bit Edition final release will be available within 90 days of the release of Windows NT.
  23. Does Visual C++ 32-Bit Edition really make it easier to learn C++?
  24. Yes.  The most difficult aspect of C++ programming is designing classes.  Because Visual C++, 32-Bit Edition 
  25. includes the Microsoft Foundation Class Library version 2.0, you don't have to design a class library from scratch.  
  26. Microsoft Foundation Class Library version 2.0 provides a high level framework that you can "fill in" and extend 
  27. with application specific code.  To get started you can fill in the framework by writing C code.  Then, as you get a 
  28. feel for classes and Object Oriented Programming (OOP), you can begin to design your own classes to extend the 
  29. framework.
  30. The next most difficult aspect of C++ programming is learning the new syntax for working with classes (class 
  31. declarations, constructors, and destructors).  AppWizard and ClassWizard get you started by creating new classes 
  32. with complete constructors and destructors for you.  You can be immediately productive and then learn C++ by 
  33. example and extension as you go.
  34. How much disk space does Visual C++, 32-Bit Edition require?
  35. Visual C++ 32-Bit Edition will require 80MB for complete hard disk installation.  It can also be run directly from 
  36. the CD-ROM, in which case only 6MB is needed on your local hard disk.
  37. How much RAM does Visual C++, 32-Bit Edition require?
  38. Visual C++ 32-Bit Edition requires a host computer running Windows NT version 3.1, with a minimum of 16 
  39. megabytes of RAM.  20 megabytes is recommended for improved performance.
  40. By choosing Visual C++, 32-Bit Edition, will I be restricting available choices with 
  41. respect to other or future development tool alternatives?
  42. To further boost programmers' productivity, we have designed Visual C++, 32-Bit Edition to be a highly integrated 
  43. system with support for additional tools through the Tools menu.  We are supporting also tools standards, and 
  44. producing standard output formats, such as the CodeView OMF, and the Windows NT .EXE format. We are 
  45. promoting and supporting the notion of reusable code so that developers can develop applications faster and with 
  46. less work.   With these new tools, standards, and reusable components available from MICROSOFT and other 
  47. vendors, we think that programmers in greater numbers will be able to develop richer solutions than ever before.
  48. SDK Tools
  49. Does Visual C++ 32-Bit Edition include all of the SDKs for both Windows and 
  50. Windows NT?
  51. Visual C++ 32-Bit Edition includes all of the Win32 SDK tools needed to build 32-bit applications for Windows 
  52. NT.  It also includes Win32s, a product that allows Win32 applications for Windows NT to run binary-compatibly 
  53. on Microsoft Windows 3.1.
  54. How do I override the system paths that point to the Win32 SDK?
  55. If you installed the Win32 SDK for Windows NT while logged in as Administrator, the SDK Setup program 
  56. modifies your System (rather than User) environment variables. If you then install Visual C++ for Windows NT at 
  57. the user level, path conflicts will occur, since system environment variables are set before user environment 
  58. variables. 
  59. To clear the appropriate system paths:
  60. 1.    Log onto Windows NT as Administrator.
  61. 2.    Start the REGEDT32 program. 
  62. 3.    Select the HKEY_LOCAL_MACHINE window. 
  63. 4.    Expand the following sub-folders in order:
  64.         1. System
  65.         2. CurrentControlSet
  66.         3. Control
  67.         4. Session Manager
  68.         5. Environment
  69. 5.    Remove the path entry that points to the Win32 SDK executable files by double-clicking the "Path" string 
  70. in the right-hand split window. The String Editor dialog box appears. Delete only the section of the path 
  71. string which points to the Win32 SDK subdirectory. The section to delete will look similar to the 
  72. following:
  73.  
  74.     %SystemRoot%\mstools\bin;
  75.  
  76. Do not delete any other sections of this path string. When you are finished, choose OK.
  77. 6.    Remove the entry that points to the Win32 SDK library files by double-clicking the "Lib" string in the 
  78. right-hand split window. Again, the String Editor dialog box appears. Clear the contents of this dialog box 
  79. and choose OK.
  80. 7.    Remove the entry that points to the Win32 SDK include files by repeating step #5 for the "Include" string. 
  81. 8.    Close REGEDT32. This saves the new registry entries.
  82. 9.    Restart Windows NT to use the new paths.
  83.  
  84. How do I move my Win32 SDK source files to Visual C++?
  85. In the vast majority of cases, no changes need to be made. You'll need to make changes only in the following 
  86. special situations:
  87. *    Use the double-underscore keywords __try, __except, __finally, and __leave instead of try, except, finally, 
  88. and leave, or else add your own #define statements.
  89.     The SDK header file EXCPT.H defines try, except, finally, and leave as their double-underscore 
  90. counterparts, which are the actual keywords. These definitions have been removed from Visual C++ for 
  91. Windows NT, to avoid conflicts with the ANSI specification.
  92. *    In header files, use the push and pop syntax when you use #pragma pack.
  93.     The compiler issues a warning when a header file changes pack size, but header files from the Win32 SDK 
  94. turn this warning off. The Visual C++ header files use the push and pop feature to save and restore the 
  95. existing pack size and do not turn this warning off. As a result, if you have a header file that changes 
  96. default pack size, this warning may appear.
  97.     To avoid this warning, use #pragma pack(push, identifier, n) and #pragma pack(pop, identifier) instead 
  98. of #pragma pack(n) and #pragma pack(). See C Language Reference for more information on these 
  99. pragmas.
  100. *    Examine code that uses the localeconv function, checks for the return value of CHAR_MAX, and is 
  101. compiled with the /J command-line option. With Visual C++ for Windows NT, if you use the /J compiler 
  102. option, localeconv will return CHAR_MAX as 255 instead of 127.
  103.     The localeconv function from the Win32 SDK returns an error value 127, independent of the /J command-
  104. line option, which makes unsigned characters the default. In Visual C++ for Windows NT, the /J 
  105. command-line option will adjust the return value to match the new value of CHAR_MAX.
  106.  
  107. How do I use my Win32 SDK Makefiles with Visual C++?
  108. Update your SDK makefiles and then run the makefiles from the command line or as an external project in Visual 
  109. Workbench. In general, the following changes need to be made:
  110. *    Remove calls to the CVTRES and CVTOMF utilities.
  111.     These are tools in the SDK which convert .RES files (output from RC) and 32-bit OMF object files 
  112. (typically from MASM) to COFF format for the linker. These utilities are obsolete, because the Visual C++ 
  113. linker can link the .RES and OMF .OBJ files directly.
  114. *    Replace any occurrences of CRTDLL.LIB with MSVCRT.LIB.
  115.     In the SDK, the DLL version of the C run-time library is supported with the import library CRTDLL.LIB. 
  116. In Visual C++ for Windows NT, the import library and DLL are MSVCRT.LIB and MSVCRTnn.DLL, 
  117. where nn is the version number of the DLL (currently 10).
  118. *    Remove references to non-Intel platforms.
  119.     Visual C++ for Windows NT generates code for Intel-compatible processors only. The following 
  120. command-line options are not supported: /Zh, /QmipsG1, /QmipsG2, and /Gt. (The /Gt option supports 32-
  121. bit applications for MIPS processors and 16-bit applications for Intel processors, but not 32-bit applications 
  122. for Intel.)
  123. *    For DLLs with no entry point, add the /noentry option to the LINK command line.
  124.     With the Windows NT SDK, if a DLL is linked without the /entry option, the DLL will be created with no 
  125. entry point. In Visual C++ for Windows NT, the default for DLLs is to use the entry point 
  126. _DllMainCRTStartup, which will automatically initialize the C run-time library.
  127. *    Optionally, remove the trailing "32"  and "386" from LINK and CL.
  128.     With Visual C++ for Windows NT, the "stub" utilities LINK32 and CL386 execute LINK and CL, 
  129. respectively, and print a warning message. The actual linker and driver have been renamed to LINK and 
  130. CL, but the stub utilities are included for makefile compatibility. You can slightly reduce your build time 
  131. by calling the actual utilities directly.
  132.  
  133. Compiler 
  134. What are the major differences between Visual C++ 32-Bit Edition and the SDK 
  135. compiler and utilities?
  136. With few exceptions, the compiler, utilities, and run-time library support the same behavior. However, the Visual 
  137. C++ utilities have new features for better usability and error detection. For example, the Visual C++ compiler 
  138. supports the /G5 option for generating Pentium code. For information on new features, see Help on individual 
  139. utilities. For specific changes you might need to make, see other questions in this category.
  140. Visual C++ for Windows NT provides a complete set of well-tested and documented tools for the development of 
  141. Win32 and Win32s applications. You can write most applications without the Win32 SDK, but in a few cases you 
  142. may need to use the Win32 SDK and Visual C++ together.  The table below outlines some differences between the 
  143. tool sets.
  144. Table of Win32 SDK and Visual C++ Tools
  145.  
  146. Win32 SDK
  147. Visual C++
  148.  
  149. API Profiler
  150. Source Profiler
  151.  
  152. BIND
  153. EDITBIN /BIND
  154.  
  155. CVTRES
  156. Incorporated into LINK
  157.  
  158. CVTOMF
  159. Obsolete
  160.  
  161. Dialog Editor
  162. App Studio
  163.  
  164. Image Editor
  165. App Studio
  166.  
  167. Font Editor
  168. None
  169.  
  170. WinDbg
  171. Visual Workbench and CodeView 
  172. for Win32s
  173.  
  174. M Editor
  175. Visual Workbench
  176.  
  177. MASM
  178. Inline assembler
  179.  
  180. Microsoft Test 1.0
  181. None
  182.  
  183. NTSD
  184. Visual Workbench
  185.  
  186. OLE 2.0 Toolkit (Beta)
  187. None
  188.  
  189. RPC toolkit
  190. None
  191.  
  192. REBASE
  193. EDITBIN /REBASE
  194.  
  195. Setup Toolkit
  196. None
  197.  
  198. Spy
  199. SPY++
  200.  
  201. SYMEDIT
  202. None
  203.  
  204. Working Set Tuner
  205. Source Profiler
  206.  
  207.  
  208. Microsoft compilers have been slow in the past.  How does Visual C++ 32-Bit 
  209. Edition perform.
  210. Our compile and link speeds are very competitive.  We have a white paper that goes into bench-marking issues in 
  211. detail.
  212.  
  213. How can I modify the header of a 32-bit executable file?
  214. EDITBIN.EXE lets you modify the header of a 32-bit .EXE, .DLL, or .OBJ file. To examine 32-bit executable files, 
  215. use the DUMPBIN tool. EDITBIN is described in  \MSVCNT\HELP\EDITBIN.WRI, and DUMPBIN is described 
  216. in Build Tools User's Guide.
  217. These tools replace the /edit and /dump options from the SDK linker.
  218. Does Visual C++, 32-Bit Edition support templates? Does Visual C++, 32-Bit 
  219. Edition support the 3.0 language standard?
  220. This question really boils down to whether or not Visual C++, 32-Bit Edition supports templates.  We considered 
  221. this feature seriously and believe that, while there is a lot of market hype about templates, they aren't what C++ 
  222. programmers need most today.  For the majority of users, concerned with learning C++, templates make the 
  223. learning issues more complex.  Our goal in building Visual C++, 32-Bit Edition was to make moving to C++ and 
  224. Microsoft Windows NT programming easier by offering streamlined integration, powerful reusable components, 
  225. and wizards that perform the most complex tasks for you.  We believe, however, that the ANSI standard is 
  226. important.  We will add support for templates to the compiler in the future when more customers indicate that this 
  227. is high priority for them.
  228. Resource Tools
  229. What is App Studio?
  230. App Studio provides complete windows resource editing. The most important advantage is that App Studio in 
  231. combination with ClassWizard lets you connect user interface objects (forms, dialogs, menu items, accelerators, 
  232. etc.) to code.  One of the unique advantages of Visual C++, 32-Bit Edition over other systems is its streamlined 
  233. integration.  When you open a resource file in the Visual Workbench, it can be automatically opened into App 
  234. Studio.  When you compile an application in the Visual Workbench, any changes made to the project's resource file 
  235. are automatically saved.  This kind of integration, provides a high level of overall productivity.  
  236. *    Copy and move resources, controls, menu items via drag and drop between resources or files. 
  237. *    Search by prefix to find resources/symbols, instead of having to scroll through lists.
  238. *    Most recently used access to previously opened files.
  239. *    Toolbar.
  240. *    Context sensitive help by pointing to objects.
  241. *    ClassWizard and App Studio allow you to select user interface objects, browse their messages and connect 
  242. them to code.
  243. *    Automatic linking to application framework features such as menu prompt strings, command ID 
  244. management, toolbar editing.
  245. *    Open multiple files via MDI.
  246. *    App Studio will read any Microsoft .RC file.
  247. *    Automatic symbol value management (picks unique symbols, or allows English names)
  248. *    F7 will automatically size to content on any button, check box, or static text.
  249. *    Preview graphics before opening in editor.
  250. *    Greater graphics editing including custom brushes; direct manipulation cropping and scaling; editing tiled 
  251. bitmaps; flip vertical/horizontal; invert colors' transparent and opaque drawing.
  252. *    Direct manipulation menu editing.
  253. *    View all strings in a string table in a  single view.
  254. *    Search for string by ID or content.
  255. *    Select multiple strings.
  256.  
  257. Which SDK tools has App Studio replaced?
  258. The tools that are no longer necessary, and have therefore been removed, are ImageEdit and DlgEdit. The other 
  259. tools are still included.
  260. What's different in the 32-bit edition of App Studio?
  261. App Studio for Windows NT has the following differences:
  262. *    VBX custom controls are not supported
  263. *    App Studio for Windows NT cannot load and save Windows NT executable files (.EXE), dynamic-link 
  264. libraries (.DLL) or resource files (.RES).
  265. *    App Studio for Windows NT does not support resources or resource objects specific to Windows NT.
  266. *    App Studio for Windows NT stores information about initialization and configuration within the 
  267. configuration registry instead of APPSTUDIO.INI.
  268.  
  269. For more information, see "App Studio Update" in App Studio User's Guide.
  270. Does App Studio let me work on my RC files without modification and keep my 
  271. comments and conditionals?
  272. AppStudio may not save some information defined in an RC file (i.e., comments, pre-processor directives, or 
  273. macros), however, it will warn the user in this case.   
  274. Can App Studio manage resources in multiple resource files?
  275. The App Studio Set Includes feature allows you to structure resource files any way you need to.  It fully supports 
  276. nested include files, multiple header files, and other features needed for sophisticated projects.  App Studio also 
  277. supports the notion of a "Compile Time Only" resource, which allows you to define resources that will not be 
  278. edited by App Studio.  This gives you full control of resource definitions that require macros or embedded 
  279. preprocessor directives (features not supported by App Studio).  For large projects with hundreds of resources you 
  280. want to be able to selectively edit resources in specific files.  In App Studio you can open the specific resource file 
  281. you want to edit.  When you open a resource file all included files are always opened as well.
  282. Visual Basic
  283. Can I use all Visual Basic Custom Controls with Visual C++, 32-Bit Edition?
  284. Visual C++, 32-Bit Edition, is a 32-bit product, and as a result, does not support the use of existing 16-bit Visual 
  285. Basic controls.  The 32-bit architecture for Visual Basic controls is still under development.  Visual C++ 32-Bit 
  286. Edition will be updated to support the 32-bit control architecture when it becomes available.
  287. Targeting (DOS, OS/2*, NT* and Macintosh*. Also, 386, 486, P5) 
  288. Can I build 32-bit applications from MS-DOS?
  289. Yes. All of the command-line tools provided with Visual C++ for Windows NT are MS-DOS extended. They can 
  290. be run directly from the MS-DOS command prompt and do not require a separate DOS extender or memory 
  291. manager.
  292. Before building a 32-bit application, you should to set the INCLUDE, LIB, and PATH environment variables to 
  293. point to the directories containing the 32-bit versions.
  294. How do I build 16-bit applications from Windows NT?
  295. If you have both Visual C++ for Windows, Version 1.0 and Visual C++ for Windows NT installed on your 
  296. machine, you can develop 16-bit Windows and MS-DOS applications from the Visual Workbench or from the 
  297. command line.
  298. The BETA2FIX utility modifies the command-line tools from Visual C++ for Windows to run under Windows NT. 
  299. You can also convert them back so that they can be used from Windows 3.1 and MS-DOS.
  300. To make the command-line tools from Visual C++ for Windows available under Windows NT:
  301. 1.    Make sure that BETA2.DLL is in your path.
  302. 2.    From the Windows NT command line, move to the directory containing 16-bit Visual C++ executable files 
  303. (by default, \MSVC\BIN).
  304. 3.    Enter BETA2FIX /V *.EXE
  305.  
  306. To build 16-bit applications from the Visual Workbench:
  307. 1.    Convert the command-line tools as described above. 
  308. 2.    Start the Visual Workbench from Visual C++ for Windows NT. 
  309. 3.    From the Options menu, choose Directories. Update the paths to point to the 16-bit version of each.
  310. 4.    From the Project menu, choose Open. Select the "Use as an external makefile" option and load your project 
  311. makefile.
  312. 5.    Build and execute the program as usual.
  313.  
  314. Note  Visual C++ for Windows NT cannot debug 16-bit executable files. In addition, context-sensitive keyword 
  315. help does not work 
  316. To make the command-line tools from Visual C++ for Windows available under Windows 3.1 again:
  317. 1.    From the Windows NT command line, move to the directory containing 16-bit Visual C++ executable files 
  318. (by default, \MSVC\BIN).
  319. 2.    Enter BETA2FIX /U *.EXE
  320.  
  321. BETA2FIX.EXE and BETA2.DLL are available from the following sources:
  322. *    CompuServe: Microsoft Windows NT download section
  323. *    Internet: FTP from UUNET.UU.NET under /vendors/Microsoft
  324. *    Microsoft Developer Network (MSDN) CD-ROM: Fall 1993 and later
  325. *    Microsoft Download Service (MSDL): (206) 936-MSDL in the United States (contact local subsidiary for 
  326. other countries).
  327.  
  328. Can I convert 16-bit projects into 32-bit projects?
  329. Yes. If you are converting your application to you can use the CVTMAKE sample program to convert your project 
  330. files to work as internal makefiles. 
  331. CVTMAKE is ready to compile in the \MSVCNT\SAMPLES\CVTMAKE. See CVTMAKE.WRI in the same 
  332. directory for more information.
  333. How do I port 16-bit applications to 32 bits?
  334. The Visual C++ for Windows NT documentation describes porting 16-bit applications.
  335. *    Migrating 16-bit MFC applications is described in "Microsoft Foundation Class Library Update" in Class 
  336. Library Reference.
  337. *    For information on porting 16-bit Windows applications to Win32, see "Porting 16-bit code to 32-bit 
  338. Windows" in Programming Techniques.
  339. *    Applications that use standard I/O calls such as printf and scanf can be built as Console applications 
  340. under Windows NT. Function compatibility is described in C Run-Time Library Reference.
  341.  
  342. How do I build 32-bit applications from Visual C++ for Windows?
  343. If you have both Visual C++ for Windows, Version 1.0 and Visual C++ for Windows NT installed on your 
  344. machine, you can develop applications for Win32 and Win32s:
  345. 1.    From MS-DOS, set up the Win32s subsystem by running the setup program in the \MSVC32S directory of 
  346. the installation CD-ROM. You only need to do this once.
  347. 2.    Start Windows 3.1 and run the Visual Workbench from Visual C++ for Windows.
  348. 3.    From the Options menu, choose Directories. Update the paths to point to the 32-bit version of each.
  349. 4.    From the Project menu, choose Open. Select the "Use as an external makefile" option and load your project 
  350. makefile.
  351. 5.    Build and execute the program as usual.
  352. Note  Visual C++ for Windows cannot debug 32-bit executable files. In addition, context-sensitive keyword help 
  353. does not work 
  354. Does Visual C++ 32-Bit Edition let me write 16-bit applications for Windows 3.1?
  355. No.  Visual C++ 32-Bit Edition is designed to write 32-bit applications using the Win32 API.  The product also 
  356. includes Win32s which allows 32-bit applications to run under Windows 3.1. 
  357. Can I use the NT product to develop for Windows Version 3.1?
  358. Yes, by using Win32s, you can create applications that run binary-compatibly on both Windows NT and Windows 
  359. 3.1.
  360. Can I use the NT product to target Windows Version 3.1 directly without going 
  361. through Win32s*?
  362. No.  Win32s is required to target Windows 3.1 using Visual C++ 32-Bit Edition.
  363. Can I use the NT product to target MS-DOS?
  364. No.  You can target MS-DOS using visual C++ Professional Edition. 
  365. Will you have a DOS application framework?
  366. You can use non-user-interface features of  Microsoft Foundation Class Library in DOS applications, and  
  367. Microsoft Foundation Class Library compatible DOS application frameworks are available as additional tools, such 
  368. as MEWEL, from third party vendors.  Our current development work  is focused on Windows.  
  369. Does Visual C++ 32-Bit Edition support the Pentium?
  370. Yes.  Visual C++ 32-Bit Edition includes specific new optimization and code generation technology for the 
  371. Pentium and i486 processors.  
  372. Can I write POSIX or OS/2 applications using Visual C++ for Windows NT?
  373. The current version of Visual C++ is targeted for the Win32 and Console subsystems. However, if you install the 
  374. POSIX headers and libraries from the Microsoft Win32 Software Development Kit, you can use Visual C++ for 
  375. Windows NT to write POSIX applications. 
  376. Does Visual C++ for Windows NT target the Silicon Graphics MIPS or Digital 
  377. Equipment Alpha platforms?
  378. No, only Intel-compatible microprocessors are supported with this version.
  379. How do I build device drivers with Visual C++?
  380. Although Visual C++ does not supply all of the libraries, headers, and tools needed to create device drivers for 
  381. Windows NT, you can still use many Visual C++ components. 
  382. 1.    Update the command-line tools included with the DDK with the versions provided with Visual C++. 
  383.     Note  Not all of the tools provided in the DDK (such as MASM) are supplied with Visual C++, so be 
  384. careful when deleting files.
  385. 2.    Make appropriate changes to the source files and makefile.
  386. 3.    Use the BUILD or NMAKE utility to build the device driver.
  387. What about the Macintosh tools I've heard about?
  388. We are working on a product to allow cross platform development of applications for Windows and the Macintosh.  
  389. No other details are available.
  390. Integrated Development Environment
  391. What's different in the 32-bit edition of Visual Workbench?
  392. The Visual Workbench in Visual C++ for Windows NT has the following additions:
  393. *    32-bit Project types
  394. *    Compiler and linker options for 32-bit build tools
  395. *    Integrated Source Profiler
  396. *    Find in files capability
  397. *    Multithread debugging capability
  398. *    Win32 Structured Exception Handling debugging
  399. *    Break command on the Debug menu
  400. *    Memory window in the debugger
  401. *    Generalized output window that accepts output from custom tools added to the Tools menu
  402. *    Stop command on the tools menu that will also stop build tools
  403.  
  404. There are also some option differences in the Editor, Colors, Tools, and Debug dialog boxes.
  405. Does Visual C++, 32-Bit Edition come with an integrated Source Code 
  406. Management System and is this system fully integrated in the development 
  407. environment?
  408. Shortly after Visual C++, 32-Bit Edition releases we will have a Source Code Management System, which can be 
  409. integrated into the Visual Workbench using the Tools menu. The Source Control Management tools, however, will 
  410. not be available as part of Visual C++, 32-Bit Edition but will be offered as a stand-alone product.  You can also 
  411. integrate other source control management systems with Visual C++, 32-Bit Edition by using the tools menu.  The 
  412. code editor automatically detects changes in file access attributes, making source control tasks easy (for instance, 
  413. when a file changes from read only to read/write the code editor will automatically detect this change and then let 
  414. you edit the file without having to close and then re-open the file).
  415. Does the editor automatically insert matching brackets?
  416. The editor supports jumping to matching brackets. It doesn't automatically insert matching brackets for you.
  417. Does your editor support alternate keyboards?
  418. No.  We support alternate keyboard layouts for different countries, but no user customizable keyboard mappings.
  419. Will Visual C++, 32-Bit Edition work for really large projects? I've got a lot of 
  420. NMAKE files.
  421. Visual C++, 32-Bit Edition works with existing PWB and NMAKE files as external projects.  The internal project 
  422. manager will also handle large projects.  We've tested with projects like building Microsoft Excel and Word, and it 
  423. functions correctly and efficiently.
  424. Debugger
  425. Does the debugger have a memory window?
  426. Yes.  This often requested feature has been integrated into the debugger.
  427. Does the debugger support threads?
  428. Yes.  The debugger includes support for Windows NT threads.  The threads dialog allows you to view the threads 
  429. in your application, pause or resume them, get a stack trace, and more.
  430. Does the debugger support Exceptions?
  431. Yes.  The debugger supports Windows NT exceptions.  You can determine what the debugger should do for a 
  432. given exception.  Stop always, or stop only if unhandled.
  433. Wizards
  434. I have a large base of  C code. Will the Wizards work for me too?
  435. Both of the Wizards in Visual C++, 32-Bit Edition, AppWizard and ClassWizard, are designed expressly for the 
  436. Microsoft Foundation Class Library (and C++) programmer.  AppWizard is ideal for starting new projects that use 
  437. Microsoft Foundation Class Library version 2.0 and C++.  It's a great teaching tool as well-take a look at the 
  438. skeleton application that it creates.  If you are a Microsoft Foundation Class Library version 1.0 programmer, you 
  439. can easily import your Microsoft Foundation Class Library version 1.0 code into ClassWizard by following the 
  440. simple instructions outlined in the on-line technical note.  We see the Wizards being used as people migrate their 
  441. code to C++ or start new projects in C++.  There are a few additions you need to make to your existing code to 
  442. allow for mixed Microsoft Foundation Class Library/C++ and C code, and then new modules can be done in C++.
  443. Why can't I change my mind with AppWizard and change from MDI to Non-MDI or 
  444. add (Object Linking and Embedding) OLE support later?
  445. AppWizard is a tool for creating an application quickly.  To change, you should recreate a new application and 
  446. move your implementations over.  To switch an SDI app to MDI manually using the Visual WorkBench is 
  447. relatively simple.
  448. Why doesn't AppWizard have more options, such as letting me specify the base 
  449. classes of my view, or OLE server?
  450. AppWizard is designed to create a skeleton for a generic application with as few steps as necessary.  Most other 
  451. modifications can be done very simply with only a few changes using the Visual WorkBench editor.  For example, 
  452. removing the status bar requires deleting (or commenting out) only two lines of code.  That's because an 
  453. AppWizard application isn't a lot of code, but rather a good deal of bookkeeping information, such as declarations 
  454. for derived classes.  The power of AppWizard is in the application framework.
  455. Why isn't ClassWizard a generic class editor? (It won't let you create/browse/edit 
  456. arbitrary classes in a general way.)
  457. We have an integrated class browser for this.  ClassWizard is designed to manage classes that contain message 
  458. maps, which are generally the visual classes in your application.  The general rule is that ClassWizard can work 
  459. with classes derived, directly or indirectly, from the Microsoft Foundation Class Library version 2.0 class 
  460. CCmdTarget.
  461. Why can't I override arbitrary virtual functions with ClassWizard?
  462. ClassWizard maintains only functions that are mapped via message maps.
  463. Why doesn't ClassWizard delete a function's definition when I delete the handler?
  464. ClassWizard is designed to minimize the amount of modification it does to source files.  Since ClassWizard works 
  465. the way you do, allowing you to structure your code in an arbitrary manner, the cost of implementing this feature 
  466. was too high and would potentially involve external database files as with code generators or CASE tools.  We 
  467. advise programmers to comment out the code, rather than delete it, because the code is often reused later.  This 
  468. practice is common on large scale applications.
  469. Microsoft Foundation Class Library
  470. What's the difference in terms of learning curve between Microsoft Foundation 
  471. Class Library version 1.0 and version 2.0?
  472. Microsoft Foundation Class Library version 2.0 is easier to use and to learn because of the higher level classes.  For 
  473. instance, in version 1.0 creating a toolbar involved calling the low level GDI calls to draw buttons, etc. In 
  474. Microsoft Foundation Class Library version 2.0 all the details of a fully implemented toolbar are provided for you 
  475. in a single class.  So creating a toolbar is as simple as creating a new toolbar object. You no longer have to worry 
  476. about the low level details.
  477. What's different in the 32-bit edition of the Microsoft Foundation Class Library?
  478. The Foundation Class Library shields the programmer from most of the changes brought about by moving to 
  479. Win32. Only the message handlers CWnd::OnCommand and CWnd::OnParentNotify and the CTime class 
  480. have changed. Also, there is no support for VBX controls, the Microsoft Windows for Pen Computing extensions, 
  481. or AFXDLL (MFC200.DLL or MFC200D.DLL). 
  482. For more information, see "Microsoft Foundation Class Library Update" in Class Library Reference.
  483. Does Microsoft Foundation Class Library handle message routing for you?
  484. Microsoft Foundation Class Library handles message routing automatically using "message maps."  Windows-
  485. oriented messages are automatically mapped to class member functions.  Because messages are managed by 
  486. Microsoft Foundation Class Library, the application framework can actually cache messages and make message 
  487. handling faster than in C/SDK applications. Message maps eliminate the need to use the usual lengthy, error 
  488. prone, CASE statements traditionally found in C Windows application code.  In addition, ClassWizard lets you 
  489. connect user interfaces messages to class member functions without having to write the necessary C++ code, 
  490. making message handling fast, easy, and far less error prone. 
  491. Visual C++, 32-Bit Edition/Microsoft Foundation Class Library is creating a lot of 
  492. code for me. Is it bullet-proof and bug free?
  493. The reusable code that we provide in Visual C++, 32-Bit Edition is very solid. It's been thoroughly tested, and it's 
  494. already being used in some professional and commercial applications-like App Studio-today.
  495. How much of systems resources does Microsoft Foundation Class Library use?
  496. The exact amount of memory, system resources, and hard disk space required by a Microsoft Foundation Class 
  497. Library application varies depending on which features you use and other code you have written to extend the 
  498. framework.  However, creating smallest and fastest executables was a top priority in Microsoft Foundation Class 
  499. Library.  The Microsoft Foundation Class Library code is developed by a team of some of the most experienced 
  500. Windows and C++ programmers at Microsoft. They focused on making the reusable code as tight as possible, 
  501. giving developers the most highly optimized code. They also made sure that Microsoft Foundation Class Library 
  502. uses as little memory and other system resources as possible.  For instance, the toolbar is implemented with a 
  503. single HWND (regardless of how many buttons there are in the toolbar) to minimize use of user heap.
  504. How many classes are there in Microsoft Foundation Class Library version 2.0?
  505. Microsoft Foundation Class Library version 2.0 offers approximately 13 new, high-level classes. In total, it 
  506. includes over 100 classes.
  507. Why does the CEditView class support only text files smaller than 64K and a 
  508. single font?
  509. CEditView is a high-level encapsulation of the Windows edit control.  We are working with the Microsoft 
  510. Windows team to provide a richer edit control in a future version of Windows that will support a larger feature set.  
  511. CEditView's purpose is to serve as a simple text editor and not as a word processor.
  512. Can Microsoft Foundation Class Library version 2.0 be compiled with other C++ 
  513. compilers?
  514. Yes.  Microsoft Foundation Class Library version 2.0 was designed and implemented using techniques that will 
  515. expedite porting to other compilers.  As with Microsoft Foundation Class Library version 1.0, the burden of porting 
  516. Microsoft Foundation Class Library version 2.0 to a compiler falls to the vendor since there are too many compiler 
  517. vendors for Microsoft to support.  We will work with any compiler vendor that wishes to participate in the 
  518. Microsoft Foundation Class Library licensing program in order to compile Microsoft Foundation Class Library 
  519. with its compiler.  Microsoft Foundation Class Library version 2.0 requires the addition of three vendor-specific 
  520. files: a version header file, a version source file, and a vendor-specific project file.  For example, the version header 
  521. file would contain any #define or #undef lines to change symbolic constants or compiler directives; the 
  522. version source file would contain any non-implemented runtime functionality; and the project file would compile 
  523. the library.  The Borland versions of these files should be less than 100 lines total.
  524. Why doesn't Microsoft Foundation Class Library version 2.0 support OLE version 
  525. 2.0?  Isn't OLE version 1.0 an old standard?
  526. OLE 2.0 is only available in beta test at this time, and Microsoft Foundation Class Library version 2.0 is a shipping 
  527. product.  As OLE 2.0 matures, Microsoft Foundation Class Library version 2.0 support will be made available.
  528. The standard OLE support built into NT is OLE 1, so we support OLE 1!  OLE 2 support using MFC was 
  529. demonstrated at the recent OLE 2 Developers Conference.  Microsoft is still working on developing MFC OLE 2 
  530. support and will make this support available when it is generally supported in the operating system.
  531. Why doesn't the Microsoft Foundation Class Library version 2.0 support Windows 
  532. NT specific features?
  533. The 32-bit version of MFC 2.0 is focused at providing a class library solution for people migrating 16-bit Windows 
  534. 3.x applications to NT and/or Win32S or for people writing or maintaining applications that target more than one 
  535. platform all using the same source code.  Therefore, the current version does not rely on any features unique to 
  536. Windows NT.
  537. Does the Microsoft Foundation Class Library version 2.0 support multi-threading?
  538. MFC supports a limited form of multi-threaded applications.  The main user interface code written in MFC must 
  539. reside in the single main thread.  Additional helper threads can be written to offload work from the main UI 
  540. thread.  These helpers threads can make use of a very limited subset of the MFC API.  Documentation provided 
  541. with MFC includes a more in-depth discussion of this support.
  542. Once you rely on threads your program will only be able to run on one of the three platforms that MFC supports 
  543. (Win16 and Win32S do not support threads).  Therefore it is recommended that you should try to abstract out those 
  544. helper threads so that your program can run on these systems if appropriate.
  545. How do I move existing 16-bit MFC 2 applications to Windows NT?
  546. The easiest way to do this is to create a new project file, add the source files to it and recompile with the Visual 
  547. C++ 32-bit edition compiler/IDE.  You will, of course, have to fix any non-portable application code that you may 
  548. have written.
  549. #########
  550.  
  551.  
  552. Microsoft is a registered trademark and Windows, Windows NT, Win32, Win32s, Visual Basic and Visual C++ are trademarks of 
  553. Microsoft Corporation.
  554. CompuServe is a registered trademark of CompuServe, Inc.
  555. Borland is a registered trademark of Borland International, Inc.
  556. Copyright ⌐ 1993 by Microsoft Corporation
  557.  
  558. This document may be reprinted with attribution for non-commercial, informational purposes by members 
  559. of the press or academic institutions.  Any other use requires the express written consent of Microsoft 
  560. Corporation.
  561.  
  562. The information contained in this document represents the current view of Microsoft Corporation on the issues 
  563. discussed as of the date of publication.  Because Microsoft must respond to changing market conditions, it should 
  564. not be interpreted to be a commitment on the part of Microsoft, and Microsoft cannot guarantee the accuracy of 
  565. any information presented after the date of publication.
  566. This document is for informational purposes only.  MICROSOFT MAKES NO WARRANTIES, EXPRESS 
  567. OR IMPLIED, IN THIS DOCUMENT.
  568.  
  569.  
  570.  
  571.  
  572.  
  573.  
  574. Microsoft Visual C++, 32-bit Edition:  Questions and Answers    Page 14
  575.  
  576.  
  577.  
  578.  
  579.